home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / musik / MIDIFP21 / SOURCES / MIDI_PRT / DRAWER / DRAWER.C < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-24  |  20.6 KB  |  650 lines
  1. /**************************************************************
  2. *
  3. *                DRAWER.C
  4. *
  5. **************************************************************/
  6.  
  7. #include <acs.h>
  8. #include <acsplus.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <messages.pif>
  12. #include <acs_plus.pif>
  13. #include <graphics.pif>
  14. #include <notimtab.pif>
  15. #include "..\filter\filter.pif"
  16. #include "..\params\params.pif"
  17. #include "..\info\info.pif"
  18.  
  19. #include "drawer.pif"
  20. #include "drawer.h"
  21. #include "drawer.ah"
  22.  
  23. #define MAX_NOTE_HEIGHT 127
  24.  
  25. #define HEADLINE_DIVIDER 3 /* headl.height = syst.dist./HEADLINE_DIVIDER */
  26. #define INDEX_CHARACTERS 2 /* max. number of characters for index */
  27.  
  28.  
  29. /************* OBJECT DATA PROTOTYPE BEGIN ***********************/
  30.  
  31.  
  32. #define HEADLINE_HEIGHT 12   /* [points] */
  33. #define INDEX_HEIGHT     8   /* [points] */
  34. #define TRACK_HEIGHT     8   /* [points] */
  35.  
  36. /*** possible values for page type ***/
  37.  
  38. #define NO         0x00  /* no valid type */
  39. #define MULTIPLE   0x01  /* one or more whole note systems fit onto this page */
  40. #define PRECEEDING 0x02  /* the tail of the system is on a succeeding page */
  41. #define SUCCEEDING 0x04  /* the head of the system is on a preceeding page */
  42.  
  43. typedef struct 
  44. {
  45.     char number_of_systems ;           /* on this page */
  46.     char type ;                        /* see above */
  47.     int first_track, last_track ;      /* to be drawn for this page */
  48.     TIME min_time ;                    /* in ticks */
  49. } 
  50. PAGE_DESCRIPTOR ;
  51.  
  52. #define MAX_PAGES   200
  53.  
  54. typedef struct 
  55. {
  56. /*** init only data ***/
  57.  
  58.     int handle ;               /* of VDI workstation */
  59.     Awindow *obj_wi ;          /* window of GEM-object to be drawn */
  60.     int obj ;                  /* index of GEM-object to be drawn */
  61.     int width, height ;        /* of GEM-object */
  62.     Awindow *params_wi,        /* related object instances */
  63.             *filter_wi,        /* for access to their hidden data */
  64.             *info_wi ;     
  65.     int ntrks ;                /* number of tracks to be treated */
  66.  
  67. /*** read/write data ***/
  68.  
  69.     int font_id ;
  70.     int current_page ;                 /* number of page that shall be displayed */
  71.     int npgs ;                         /* number of pages with valid layout */
  72.     PAGE_DESCRIPTOR page[MAX_PAGES] ;  /* drawing layout for all pages */
  73.     int x_min, x_max, y_min, y_max ;   /* maximum area allowed for whole drawing */
  74.     int x_min_systems, x_max_systems,  /* same for drawing note systems */
  75.         y_min_systems, y_max_systems ;
  76.     float dy_system, dy_track ; 
  77.     float dy_note, dy_line ;            /* y-distances */
  78.     float dx_bars ;                     /* x-distance */
  79.     float beats_per_system ;            /* quarter beats */
  80.     int bars_per_system ;
  81.     char bar_divider ;
  82.     TIME time_per_system ;              /* in ticks per system */
  83. } 
  84. DRAWER ;
  85.  
  86. /************* OBJECT DATA PROTOTYPE END *************************/
  87.  
  88.  
  89. /*******************************************************************
  90. */
  91.     static void keys(Awindow *wi, int kstate, int key)
  92.     
  93. /* Keyboard procedure of the drawer window. See ACS manual.
  94. *
  95. *******************************************************************/
  96. {
  97.     /*** delayed update ***/
  98.     if (set_timer(wi) == -1) Awi_sendall(REDRAW, wi) ;
  99.     
  100.     /*** inform other windows about key pressure ***/
  101.     key_message.sender = wi ;
  102.     key_message.kstate = kstate ;
  103.     key_message.key    = key ;
  104.     Awi_sendall(KEY_PRESS, &key_message) ;
  105.     
  106.     /*** forward event to ACS for further treatment (e.g. by the desktop) ***/
  107.     Awi_keys(wi, kstate, key) ;
  108. }
  109.  
  110. /*******************************************************************
  111. */
  112.     static int service(Awindow *wi, int task, void *not_used)
  113.     
  114. /* Service routine for messages sent to this window. See ACS manual.
  115. * 
  116. * OUTPUT:  AS_TERM ==> message is forwarded to parent
  117. *          AS_INFO ==> a little help function 
  118. * 
  119. * RETURN:  TRUE:        if task could be treated
  120. *          FALSE:       else
  121. * 
  122. *******************************************************************/
  123. {
  124.     switch (task)
  125.     {    
  126.         case AS_TERM: Awi_sendall(TERMINATE, wi) ; break ; 
  127.         case AS_INFO: A_dialog(&DRAWER_INFO) ; break ;
  128.         default:      return FALSE ;
  129.     }
  130.     return TRUE ;
  131. }
  132.  
  133. /************/
  134. void expand /*
  135. *************/
  136. (
  137.     char lines_per_12,            /* IN: so many horizontal lines are used per 12 notes */
  138.     NOTE min_note,                 /* IN: marks the minimum of the range to be expanded */
  139.     NOTE max_note,                 /* IN: marks the maximum of the range to be expanded */
  140.     NOTE *note_of_first_line ,    /* OUT: first note of the expanded range */
  141.     char *number_of_lines,         /* OUT: the expanded range consists of n*(*number_of_lines) notes */
  142.     char *first_modulo_0        /* OUT: indicates the first line with note mod m == 0 */
  143. )
  144. {
  145.     char notes_per_line = 12 / lines_per_12 ;
  146.     *note_of_first_line = min_note / notes_per_line * notes_per_line ;
  147.  
  148.     *number_of_lines = (max_note - *note_of_first_line + notes_per_line - 1) / 
  149.                         notes_per_line + 1 ; 
  150.     *first_modulo_0 = (lines_per_12 - *note_of_first_line % 12 / notes_per_line) %
  151.                         lines_per_12 ;
  152. }
  153.  
  154. /*************************/
  155. static void button(void) /*
  156. **************************/
  157. {
  158.     switch (ev_obnr) 
  159.     {
  160.     case FIRST:    select_page(ev_window, first) ; break ;
  161.     case PREVIOUS: select_page(ev_window, previous) ; break ;
  162.     case NEXT:     select_page(ev_window, next) ; break ;
  163.     case LAST:     select_page(ev_window, last) ; break ;
  164.     case ZOOM_IN:  Awi_sendall(ZOOM_PLUS, ev_window) ; break ;
  165.     case ZOOM_OUT: Awi_sendall(ZOOM_MINUS, ev_window) ; break ;
  166.     }
  167. }
  168.  
  169. /*******************************************************************
  170. *
  171. *             PUBLISHED INTERFACE
  172. *
  173. *******************************************************************/
  174.  
  175.  
  176. void select_page(Awindow *wi, SELECT_MODE sm) 
  177. {
  178. DRAWER *d = wi->user ;
  179. char *text ;
  180.  
  181.     /*** determine page to be drawn ***/
  182.     if (sm == first) d->current_page = 0 ;
  183.     if (sm == previous)
  184.     {
  185.         if (d->current_page > 0) d->current_page -- ;
  186.         else 
  187.         {
  188.             alert_str(FIRST_PAGE, "") ;
  189.             return ;
  190.         }
  191.     }
  192.     if (sm == next)
  193.     {    
  194.         if (d->current_page < d->npgs - 1) d->current_page ++ ;
  195.         else 
  196.         {
  197.             alert_str(LAST_PAGE, "") ;
  198.             return ;
  199.         }
  200.     }
  201.     if (sm == last) d->current_page = d->npgs - 1 ;
  202.     if (d->current_page > d->npgs - 1) d->current_page = d->npgs - 1 ;
  203.  
  204.     /*** refresh page number in the GEM-object ***/
  205.     text = wi->work[PAGE].ob_spec.tedinfo->te_ptext ;
  206.     if (d->current_page < 100) 
  207.     { 
  208.         text[0] = '0' ; 
  209.         text++ ;
  210.     }
  211.     if (d->current_page < 10) 
  212.     {
  213.         text[0] = '0' ; 
  214.         text++ ;
  215.     }
  216.     itoa( d->current_page, text, 10) ;
  217.     Awi_obchange(wi, PAGE, -1) ;
  218.  
  219.     /*** draw with new parameters ***/ 
  220.     if (sm != same) redraw(wi) ; 
  221. }
  222.  
  223.  
  224. int get_first_page(Awindow *wi)
  225. { return 0 ; }
  226.  
  227.  
  228. int get_last_page(Awindow *wi)
  229. { return ((DRAWER *)wi->user)->npgs - 1 ; }
  230.  
  231.  
  232. static int DRAWER_init(Awindow *wi)
  233. { 
  234.     select_page(wi, same) ; 
  235.     return OK ;
  236. }
  237.  
  238. int get_current_page(Awindow *wi)
  239. { 
  240. DRAWER *d = wi->user ;
  241.  
  242.     d->current_page = atoi(wi->work[PAGE].ob_spec.tedinfo->te_ptext) ;
  243.     if (d->current_page > d->npgs - 1) d->current_page = d->npgs - 1 ;
  244.     wi->state |= AWS_LATEUPDATE ;    /* call DRAWER_init() later */
  245.     return d->current_page ;
  246. }
  247.  
  248.  
  249. void redraw(Awindow *wi)
  250. {
  251. DRAWER *d = wi->user ;
  252.  
  253.     /*** layout all pages ***/
  254.     if ( page_layouter(d->handle, d->width, d->height, wi) == LAYOUT_ERR )
  255.         return ;
  256.     /*** refresh target object ***/
  257.     Awi_obchange(d->obj_wi, d->obj, (d->obj_wi)->work[d->obj].ob_state) ;
  258. }
  259.  
  260.  
  261. void draw_page(int handle, Awindow *wi, int x0, int y0, int *points, 
  262.                int zoom, int page)
  263. {
  264. DRAWER *d = wi->user ;
  265. PAGE_DESCRIPTOR *p = &d->page[page] ;
  266. TIME min_time, max_time ;
  267. NOTE min_note, max_note, note_of_y ;
  268. char *track_name, *text = "----" ;
  269. float y_min, y_max ;
  270. int system, track ;
  271. char number_of_lines, first_shadow ;
  272. int index_width, dummy ;
  273. int style[12], color[12], type, height, dynamic, mode ;
  274. MARK_MODE back_mode ;
  275. int hor_lines, back_style[12], back_color[12], 
  276.     black[12] = { 1,1,1,1,1,1,1,1,1,1,1,1 }, dots ;
  277. float dyn_scale ;
  278.  
  279.     if (d->npgs == 0) return ;
  280.     vst_font(handle, d->font_id) ;
  281.  
  282.     /*** draw title and page number ***/
  283.     if (y0 + d->y_min_systems * zoom > points[1])
  284.     {
  285.         vst_height(handle, (d->dy_system * zoom)/HEADLINE_DIVIDER, 
  286.                    &dummy, &dummy, &dummy, &dummy) ;
  287.         vst_alignment(handle, 1, 2, &dummy, &dummy) ;
  288.         vst_effects(handle, get_text_effects(d->params_wi)) ;
  289.         v_gtext(handle, 
  290.                 x0 + ((d->x_min + d->x_max)>>1) * zoom, 
  291.                 y0 + d->y_min * zoom, 
  292.                 get_title(d->params_wi)) ;
  293.         vst_alignment(handle, 2, 2, &dummy, &dummy) ;
  294.         vst_effects(handle, NORMAL) ;
  295.         v_gtext(handle, x0 + d->x_max * zoom, y0 + d->y_min * zoom, 
  296.                 itoa(page, text, 10)) ;
  297.     }
  298.     /*** fetch note parameters and normalize ***/
  299.     get_style_params(d->params_wi, 
  300.                      style, color, &type, &height, &dynamic,
  301.                      back_style, back_color) ;
  302.     hor_lines = get_hor_lines(d->params_wi) ;
  303.     mode = get_mode(d->params_wi) ;
  304.     height = ( d->dy_note * (height + 1) )/5 ;
  305.     dyn_scale = ( (float)dynamic ) / 10 ;
  306.  
  307.     /*** draw note system(s) ***/        
  308.     y_min = y_max = d->y_min_systems ;
  309.     if (p->type & SUCCEEDING) y_max += d->dy_track ;
  310.     for (system = 0 ; system < p->number_of_systems ; system ++)
  311.     {
  312.         min_time = p->min_time + system * d->time_per_system ;
  313.         max_time = min_time + d->time_per_system ;
  314.         for (track = p->first_track ; track <= p->last_track ; track++)
  315.         {
  316.             if ( get_min_max(d->filter_wi, track, min_time, max_time,
  317.                              &min_note, &max_note) )
  318.             {
  319.                 expand(hor_lines, min_note, max_note, 
  320.                          ¬e_of_y, &number_of_lines, &first_shadow) ;
  321.                 if (note_of_y > MAX_NOTE_HEIGHT) note_of_y = 1 ;
  322.                 y_max += d->dy_line * (number_of_lines - 1) ;
  323.                 
  324.                 /*** if track is visible (inside clipping area) ***/
  325.                 if ( ((y_max + d->dy_line) * zoom + y0 > points[1]) && 
  326.                      ((y_max - d->dy_line * (number_of_lines + 1)) * zoom + y0 < points[3]) )
  327.                 {
  328.                     /*** draw horizontal lines with index and shadow ***/
  329.                     vsl_type(handle, SOLID) ; 
  330.                     vst_height(handle, 4 * zoom * d->dy_note, &index_width, &dummy, &dummy, &dummy) ;
  331.                     vst_alignment(handle, 2, 0, &dummy, &dummy) ;
  332.                     vsf_interior(handle, FIS_PATTERN) ;
  333.                     vsf_perimeter(handle, 0) ; /* no perimeter */
  334.                     dots = -1 /* no dots */ ; back_mode = behind ;
  335.                     if (mode == Rieder) back_mode = between ;
  336.                     else if (mode == Beyreuther)
  337.                         dots = d->bars_per_system * (d->bar_divider - 1) ;
  338.                     draw_lines(handle, number_of_lines, first_shadow, hor_lines,
  339.                                back_mode, back_style, back_color, (note_of_y + 11)/12, dots,
  340.                                - index_width, 0,
  341.                                x0 + d->x_min_systems * zoom, y0 + y_max * zoom, 
  342.                                x0 + d->x_max_systems * zoom, y0 + y_max * zoom,
  343.                                0, - d->dy_line * zoom) ;
  344.                     /*** draw track name ***/
  345.                     track_name = get_track_name(d->filter_wi, track) ;
  346.                     vst_alignment(handle, 0, 3, &dummy, &dummy) ;
  347.                     vswr_mode(handle, MD_TRANS) ;
  348.                     v_gtext(handle, x0 + d->x_min_systems * zoom, 
  349.                             y0 + (y_max - (d->dy_line * (number_of_lines - 1) 
  350.                                   + d->dy_note * 2)) * zoom, track_name ) ;
  351.                     vswr_mode(handle, MD_REPLACE) ;
  352.                     /*** draw notes of the current track ***/
  353.                     vsl_color(handle, BLACK) ;
  354.                     vsf_perimeter(handle, 1) ; /* with perimeter */
  355.                     draw_track(handle, d->filter_wi, track,
  356.                                x0 + d->x_min_systems * zoom, 
  357.                                x0 + d->x_max_systems * zoom, 
  358.                                y0 + y_max * zoom, - d->dy_note * zoom,
  359.                                min_time, max_time, 
  360.                                note_of_y, height * zoom, dyn_scale, 
  361.                                type, style, color) ;
  362.                 }
  363.                 y_max += d->dy_track ;
  364.             }
  365.         }
  366.         if ( (system != p->number_of_systems - 1) || !(p->type & PRECEEDING) ) 
  367.             y_max -= d->dy_track ;
  368.         if (mode != Beyreuther)
  369.         {
  370.             /*** draw dashed horizontal lines (sub-bars) ***/
  371.             vsl_udsty(handle, 0x2222) ;
  372.             vsl_type(handle, USERLINE) ;
  373.             draw_lines(handle, (d->bars_per_system * d->bar_divider) + 1, -1, -1,
  374.                        back_mode, back_style, black, 0, -1, 0, 0,
  375.                        x0 + d->x_min_systems * zoom, y0 + y_min * zoom + 1, 
  376.                        x0 + d->x_min_systems * zoom, y0 + y_max * zoom - 1,
  377.                        d->dx_bars/d->bar_divider * zoom, 0) ;
  378.         }
  379.         /*** draw solid vertical lines (bars) ***/
  380.         vsl_type(handle, SOLID) ; 
  381.         draw_lines(handle, d->bars_per_system + 1, -1, -1,
  382.                    back_mode, back_style, black, 0, -1, 0, 0,
  383.                    x0 + d->x_min_systems * zoom, y0 + y_min * zoom + 1, 
  384.                    x0 + d->x_min_systems * zoom, y0 + y_max * zoom - 1,
  385.                    d->dx_bars * zoom, 0) ;
  386.         /*** draw bar number ***/
  387.         vswr_mode(handle, MD_TRANS) ;
  388.         vst_alignment(handle, 2, 3, &dummy, &dummy) ;
  389.         v_gtext(handle, x0 + d->x_max_systems * zoom, 
  390.                 y0 + (y_min - d->dy_note) * zoom, 
  391.                 itoa(max_time/d->time_per_system * d->bars_per_system, text, 10)) ;
  392.         vswr_mode(handle, MD_REPLACE) ;
  393.         y_max += d->dy_system ; y_min = y_max ;
  394.     }
  395. }
  396.  
  397.  
  398. int page_layouter(int handle, int width, int height, Awindow *wi)
  399. {
  400. DRAWER *d = wi->user ;
  401. int index_width, index_height, headline_width, headline_height ; 
  402. char number_of_lines, first_modulo_0 ;
  403. int first_active_track, last_active_track ;
  404. PAGE_DESCRIPTOR *page ;   
  405. int p ;                   /* page number */
  406. int t ;                   /* track number */
  407. float y ;                 /* current y value */
  408. NOTE min_note, max_note, note_of_y ;
  409. TIME time, max_time ;
  410. int dummy, hor_lines ;
  411.  
  412.     /*** get maximum area allowed for whole drawing ***/
  413.     d->x_min = ((long)(width - 1)) * 
  414.                       get_left_border(d->params_wi) / 100 ;
  415.     d->x_max = ((long)(width - 1)) * 
  416.                       (100 - get_right_border(d->params_wi)) / 100 ;
  417.     d->y_min = ((long)(height - 1)) * 
  418.                       get_upper_border(d->params_wi) / 100 ;
  419.     d->y_max = ((long)(height - 1)) * 
  420.                       (100 - get_lower_border(d->params_wi)) / 100 ;
  421.  
  422.     /*** check for plausability ***/
  423.     if ( (d->x_min >= d->x_max) || (d->y_min >= d->y_max) )
  424.     {
  425.         alert_str(INVALID_BORDER_VALUES, "") ;
  426.         d->npgs = 0 ;
  427.         return LAYOUT_ERR ; 
  428.     }
  429.  
  430.     /*** times, bars ***/
  431.     d->beats_per_system = ((float)get_system_length(d->params_wi))/2 ;
  432.     d->time_per_system = d->beats_per_system * 
  433.                          get_ticks_per_beat(d->info_wi) ;
  434.     d->bars_per_system = get_bars_per_system(d->params_wi) ;
  435.     d->bar_divider = get_bar_divider(d->params_wi) ;
  436.  
  437.     /*** get y-distances ***/
  438.     d->dy_system = ((float)height * get_system_distance(d->params_wi)) / 100 ;
  439.     d->dy_track = ((float)height * get_track_distance(d->params_wi)) / 100 ;
  440.     d->dy_note = ((float)height * get_note_distance(d->params_wi)) / 1000 ;
  441.     hor_lines = get_hor_lines(d->params_wi) ;
  442.     switch (hor_lines)
  443.     {
  444.     case 1: d->dy_line = d->dy_note * 12 ; break ;
  445.     case 2: d->dy_line = d->dy_note * 6 ; break ;
  446.     case 3: d->dy_line = d->dy_note * 4 ; break ;
  447.     case 4:
  448.     case 5: d->dy_line = d->dy_note * 3 ; break ;
  449.     default: d->dy_line = d->dy_note * 2 ;
  450.     }
  451.  
  452.     /*** get font and its attributes ***/
  453.     d->font_id = get_font_id(d->params_wi) ;
  454.     if ( d->font_id != vst_font(handle, d->font_id) )
  455.     {
  456.         alert_str(FONT_NOT_EXISTING, "") ;
  457.         d->npgs = 0 ;
  458.         return LAYOUT_ERR ; 
  459.     } 
  460.     /*** note: actual index_height needs not to be desired height ***/
  461.     vst_height(handle, 4 * d->dy_note, 
  462.                &index_width, &index_height, &dummy, &dummy) ;
  463.     /*** note: actual headline_height needs not to be HEADLINE_HEIGHT ! ***/
  464.     vst_height(handle, d->dy_system/HEADLINE_DIVIDER, 
  465.               &headline_width, &headline_height, &dummy, &dummy) ;
  466.     
  467.     /*** get maximum area allowed for drawing note systems ***/
  468.     d->x_min_systems = d->x_min + INDEX_CHARACTERS * index_width ;
  469.     d->x_max_systems = d->x_max ;
  470.     d->y_min_systems = d->y_min + d->dy_system + headline_height/2 ;
  471.     d->y_max_systems = d->y_max ;
  472.  
  473.     /*** get x-distances ***/
  474.     d->dx_bars = ((float)(d->x_max_systems - d->x_min_systems)) /
  475.                   d->bars_per_system ;
  476.  
  477.     /*** tracks ***/
  478.     first_active_track = get_first_active_track(d->filter_wi) ;
  479.     last_active_track = get_last_active_track(d->filter_wi) ;
  480.     if ( (first_active_track < 0) || (last_active_track < 0) )
  481.     {
  482.         alert_str(ALL_TRACKS_OFF, "") ;
  483.         d->npgs = 0 ;
  484.         return LAYOUT_ERR ;
  485.     }
  486.  
  487.     /*** layout all pages ***/
  488.     p = 0 ; d->npgs = 1 ; 
  489.     page = d->page ;
  490.     page[p].min_time = 0 ;
  491.     page[p].type = NONE ;
  492.     page[p].number_of_systems = 0 ;
  493.     page[p].first_track = first_active_track ; 
  494.     t = first_active_track ;
  495.     y = d->y_min_systems ;
  496.     time = 0 ;
  497.     max_time = get_absolute_max_time(d->filter_wi) ;
  498.  
  499.     while ( (time < max_time) && (p < MAX_PAGES - 1) ) 
  500.     {
  501.         /*** layout one system ***/
  502.         while ( (t <= last_active_track) && 
  503.                 (time < max_time) && (p < MAX_PAGES - 1) )
  504.         {
  505.             if (page[p].type & SUCCEEDING) y += d->dy_track ;
  506.             while ( (y <= d->y_max_systems) && (t <= last_active_track) )
  507.             {
  508.                 /*** if this track is active ***/
  509.                 if (get_min_max(d->filter_wi, t, 
  510.                                 time, time + d->time_per_system,
  511.                                 &min_note, &max_note))
  512.                 {
  513.                     expand(hor_lines, min_note, max_note, 
  514.                              ¬e_of_y, &number_of_lines, &first_modulo_0) ;
  515.                     /*** fits each track into the allowed y-range of a page ? ***/
  516.                     if (d->dy_line * (number_of_lines - 1) > 
  517.                     d->y_max_systems - d->y_min_systems - 2 * d->dy_track)
  518.                     {
  519.                         alert_str(TRACK_TOO_HIGH, "") ;
  520.                         d->npgs = p ;    
  521.                         return LAYOUT_ERR ;
  522.                     }
  523.                     y += d->dy_line * (number_of_lines - 1) ;
  524.                     y += d->dy_track ;
  525.                 }
  526.                 t ++ ;
  527.             }
  528.             t -- ;
  529.             if (y > d->y_max_systems)
  530.             {
  531.                 /*** the current note system does not fit onto this page ***/
  532.                 if (page[p].number_of_systems == 0)
  533.                 {
  534.                     /*** this is the first system for this page ***/
  535.                     page[p].type |= PRECEEDING ; 
  536.                     page[p].last_track = t - 1 ; 
  537.                     page[p].number_of_systems = 1 ; /* but not a whole system */
  538.                     y = d->y_min_systems ;
  539.                     p ++ ; d->npgs ++ ;
  540.                     page[p].type = SUCCEEDING ;
  541.                     page[p].first_track = t ;
  542.                     page[p].number_of_systems = 0 ;
  543.                 }
  544.                 else 
  545.                 {
  546.                     /*** there are already one or more systems on this page ***/
  547.                     y = d->y_min_systems ;
  548.                     p ++ ; d->npgs ++ ;
  549.                     page[p].type = NONE ;
  550.                     t = page[p].first_track = first_active_track ;
  551.                     page[p].number_of_systems = 0 ;
  552.                 }
  553.                 page[p].min_time = time ;
  554.             }
  555.             else
  556.             {
  557.                 /*** the current note system fits onto this page ***/
  558.                 time += d->time_per_system ;
  559.                 t = first_active_track ;
  560.                 if (page[p].type == SUCCEEDING)
  561.                 {
  562.                     /*** one and only system for this page, take a new page ***/
  563.                     page[p].last_track = last_active_track ; 
  564.                     page[p].number_of_systems = 1 ; /* but not a whole system */
  565.                     y = d->y_min_systems ;
  566.                     p ++ ; if (time < max_time) d->npgs ++ ;
  567.                     page[p].type = NONE ;
  568.                     page[p].first_track = first_active_track ;
  569.                     page[p].last_track = first_active_track ;
  570.                     page[p].number_of_systems = 0 ;
  571.                     page[p].min_time = time ;
  572.                 }
  573.                 else
  574.                 {
  575.                     /*** one more system for this page ***/
  576.                     page[p].type = MULTIPLE ;
  577.                     page[p].last_track = last_active_track ;
  578.                     page[p].number_of_systems ++ ;
  579.                     y += (d->dy_system - d->dy_track) ;
  580.                     page[p+1].type = NONE ;
  581.                     page[p+1].first_track = first_active_track ;
  582.                 }
  583.             }
  584.         }
  585.     }
  586.     if (d->current_page > d->npgs - 1) d->current_page = d->npgs - 1 ;
  587.     if (d->npgs >= MAX_PAGES - 1)
  588.     {
  589.         alert_str(MAX_PAGES_REACHED, "" ) ;
  590.     }
  591.     return LAYOUT_GOOD ;
  592. }
  593.  
  594.  
  595. void reset_layout(Awindow *wi)
  596. { 
  597.     DRAWER *d = wi->user ;
  598.     page_layouter(d->handle, d->width, d->height, wi) ;
  599. }
  600.                     
  601.         
  602. void DRAWER_destructor(Awindow *wi)
  603. {
  604.     if (wi) 
  605.     {
  606.         memory_symptom = "DrDstr wi->user" ;
  607.         if (wi->user) My_free(wi->user) ;
  608.         memory_symptom = "DrDstr wi" ;
  609.         Awi_delete(wi) ;
  610.     }
  611. }
  612.  
  613.  
  614. Awindow *DRAWER_constructor(DRAWER_INIT *drawer_init)
  615. {
  616. Awindow *wi ;
  617. DRAWER *d ;
  618.  
  619.     /*** enter filename into icon text and info line ***/
  620.     DRAWER_WINDOW.iconblk = drawer_init->icon ;
  621.     DRAWER_WINDOW.iconblk->monoblk.ib_ptext = drawer_init->filename ;
  622.     DRAWER_WINDOW.info = drawer_init->filename ;
  623.  
  624.     /*** create the DRAWER window ***/
  625.     wi = Awi_create(&DRAWER_WINDOW) ;
  626.     if (!wi) return NULL ;
  627.  
  628.     /*** allocate drawer structure and initialize ***/
  629.     wi->user = d = My_alloc(sizeof *d) ;
  630.     if (!d) { DRAWER_destructor(wi) ; return NULL ;    }
  631.     d->handle = drawer_init->handle ;
  632.     d->obj_wi = drawer_init->obj_wi ;
  633.     d->obj = drawer_init->obj ;
  634.     d->width = drawer_init->width ;
  635.     d->height = drawer_init->height ;
  636.     d->params_wi = drawer_init->params_window ;
  637.     d->filter_wi = drawer_init->filter_window ;
  638.     d->info_wi = drawer_init->info_window ;
  639.     d->ntrks = get_number_of_tracks(drawer_init->info_window) ;
  640.     d->current_page = 0 ; 
  641.     d->npgs = 0 ;
  642.  
  643.     /*** draw at once ***/
  644.     redraw(wi) ; 
  645.  
  646.     /*** return success message ***/
  647.     return wi ;
  648. }
  649.  
  650.